package Blog0;

class A {
    public A() {
        demo(); // 构造方法中调用，重写的方法，会发生动态的绑定
    }
     void demo() {
        System.out.println("A :: demo");
    }
}

class B extends A {
    @Override
    public void demo() {
        System.out.println("B :: demo");
    }
}

/*
class B extends A {*//*
    @Override
    public void demo() {
        System.out.println("子类的权限限定 public > 父类的默认权限修饰符 default");
    }*//*
    @Override
    protected void demo() {
        System.out.println("子类的权限限定 protected > 父类的默认权限修饰符 default");
    }
  *//*  @Override
    void demo() {
        System.out.println("子类的默认权限限定 default == 父类的默认权限修饰符 default");
    }*//*
}*/


abstract class Shapes {
    protected String name;
    public void pint() {

    }
    abstract  void draw(); // 抽象方法，不可以被 final 修饰，修饰了无法重写该抽象方法
}

class Circle extends Shapes {
    @Override // 重写，注解 错误提醒功能，人和编译器都可以读懂的注释
    public final void draw() {
        System.out.println("画一个 🔴");
    }
}

class Stars extends Shapes {
    @Override
    public final void draw() {
        System.out.println("画一个 🌟");
    }
}


class Zoon {
    protected String name;
    public  Zoon(String name) {
        this.name = name;
    }
}

interface IFlying { // 接口的定义
    void fly(); // 抽象方法
}

interface IRuning { // 接口的定义
    void run(); // 接口中的抽象类
}

interface ISwimming { // 接口的定义
    void swim(); // 接口中的抽象类
}

class Brids extends Zoon implements IFlying { // 继承 IFlying接口的实现
    public  Brids(String name) {
        super(name); // 调用父类的构造方法，第一行
    }

    @Override
    public void fly() { // 注意重写接口中的抽象方法 ，必须是 public 的权限修饰符，
        System.out.println(super.name+ " 可以飞的飞快");
    }

}


class Fish extends Zoon implements ISwimming { // ISwimming 接口的实现
    public Fish(String name) {
        super(name);
    }

    @Override
    public void swim() {
        System.out.println(super.name+" 可以游的飞快");
    }
}

class Cats extends Zoon implements IRuning { // IRuning 接口的实现
    public Cats(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(super.name+" 可以跑的飞快");
    }
}

class Frog extends Zoon implements IRuning,ISwimming { // IRuning,ISwimming 接口的实现
    public Frog(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(super.name+" 可以跑的飞快");
    }

    @Override
    public void swim() {
        System.out.println(super.name+" 可以游得飞快");
    }
}


public class Blog06 {
    public static void main(String[] args) {
        IRuning iRuning = new Cats("年轻的猫"); // 定义 IRuning 接口类型，访问接口的抽象方法 run()
        iRuning.run();

        IFlying iFlying = new Brids("年轻的鸟"); // 定义 IFlying 接口类型，访问接口的抽象方法 fly()
        iFlying.fly();

        Frog frog = new Frog("年轻的青蛙"); // 实例化子类，访问子类中的方法
        frog.run();
        frog.swim();


    }


    public static void func(Shapes shapes) {
        shapes.draw();
    }
    public static void main4(String[] args) {
        Shapes shapes = new Circle();
        Shapes shapes1 = new Stars();
        func(shapes);
        func(shapes1);

    }

    public static void main3(String[] args) {
        A a = new B();
        a.demo();
    }

    public static void main2(String[] args) {
        A a  = new B();
        a.demo();

    }
}
